package com.bjbn.service;

import com.alibaba.fastjson.JSONObject;
import com.bjbn.bean.cache.Cache;
import com.bjbn.bean.entity.*;
import com.bjbn.bean.model.*;
import com.bjbn.util.MyDateUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.List;


@Slf4j
@Component
public class FlightHandle {

    /**
     * 航班航站动态信息
     *
     * @param message
     * @param flightAirlineService
     * @return
     */
    public static FltInfoDynamic handleFltAirline(String message, FlightAirlineService flightAirlineService) {
        try {
            if (null != message && !message.isEmpty()) {
                FltAirline airLine = JSONObject.parseObject(message, FltAirline.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                List<FlightAirline> listArpt = flightAirlineService.getFlightInfoByFlid(airLine.getFLID().toString());
                entity.setFLID(airLine.getFLID());
                int len = listArpt.size();
                System.out.println("Received csb_imf_d_fltairline_out message: " + message);
                System.out.println("航班航站长度:" + len);
                if (len == 1) {
                    // 只有一条数据时特殊处理
                    return handleOneFltAirline(entity, listArpt);
                }

                // 找出航班进出港   "A" : "D";
                String inOutFlag = "";
                if ("CAN".equals(listArpt.get(0).getAPCD())) {
                    // 首站是白云说明是离港航班
                    inOutFlag = "D";
                }

                if ("CAN".equals(listArpt.get(len - 1).getAPCD())) {
                    // 最后一站是白云说明是进港航班
                    inOutFlag = "A";
                }

                StringBuilder routeCode = new StringBuilder();
                StringBuilder routeCh = new StringBuilder();

                for (int i = 0; i < len; i++) {
                    FlightAirline arpt = listArpt.get(i);

                    String APCD = arpt.getAPCD();
                    BaseAirport bdAirport = Cache.baseAirportMap.get(APCD);
                    String CH = bdAirport == null ? APCD : bdAirport.getCnnm();
                    // 拼接航线
                    if (routeCode.length() == 0) {
                        routeCode.append(APCD);
                        routeCh.append(CH);
                    } else {
                        routeCode.append("-").append(APCD);
                        routeCh.append("-").append(CH);
                    }

                    if (i == 0) {
                        //	始发站
                        entity.setORI_APCD(APCD);
                    }

                    // 提取终点站
                    if (i == len - 1) {
                        //	目的站
                        entity.setTGT_APCD(APCD);
                    }

                    if ("A".equals(inOutFlag)) {
                        // 提取进港倒数第二个站为上一站
                        if (i == len - 2) {
                            //	上一站
                            entity.setPRE_APCD(APCD);
                            //	前站计划起飞时间
                            entity.setPRE_FPTT(arpt.getFPTT());
                            //	前站预计起飞时间
                            entity.setPRE_FETT(arpt.getFETT());
                            //	前站实际起飞时间
                            entity.setPRE_FRTT(arpt.getFRTT());
                        }

                        // 提取本站进港信息
                        if (i == len - 1) {
                            //	计划到达时间
                            entity.setFPLT(arpt.getFPLT());
                            //	预计到达时间
                            entity.setFELT(arpt.getFELT());
                            //	实际到达时间
                            entity.setFRLT(arpt.getFRLT());
                        }
                    }

                    if ("D".equals(inOutFlag)) {
                        // 提取本站出港信息
                        if (i == 0) {
                            //	计划起飞时间
                            entity.setFPTT(arpt.getFPTT());
                            //	预计起飞时间
                            entity.setFETT(arpt.getFETT());
                            //	实际起飞时间
                            entity.setFRTT(arpt.getFRTT());
                        }

                        // 提取出港第二站为下一站
                        if (i == 1) {
                            //	下一站
                            entity.setNXT_APCD(APCD);
                            //	下站计划到达时间
                            entity.setNXT_FPLT(arpt.getFPLT());
                            //	下站预计到达时间
                            entity.setNXT_FELT(arpt.getFELT());
                            //	下站实际到达时间
                            entity.setNXT_FRLT(arpt.getFRLT());
                        }

                    }
                }

                //	完整航线
                entity.setAIRL(routeCode.toString());
                //	完整航线中文名称
                entity.setAIRL_CH(routeCh.toString());

                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltAirline出错，数据：{}", message, e);
        }
        return null;
    }

    private static FltInfoDynamic handleOneFltAirline(FltInfoDynamic entity, List<FlightAirline> listArpt) {
        FlightAirline arpt = listArpt.get(0);

        if ("CAN".equals(arpt.getAPCD())) {
            String APCD = arpt.getAPCD();
            // 只能处理白云的数据
            if ("1".equals(arpt.getAPNO())) {
                entity.setORI_APCD(APCD);
                //	计划起飞时间
                entity.setFPTT(arpt.getFPTT());
                //	预计起飞时间
                entity.setFETT(arpt.getFETT());
                //	实际起飞时间
                entity.setFRTT(arpt.getFRTT());

            } else {
                if (arpt.getFPLT() != null) {
                    //	计划到达时间
                    entity.setFPLT(arpt.getFPLT());
                    //	预计到达时间
                    entity.setFELT(arpt.getFELT());
                    //	实际到达时间
                    entity.setFRLT(arpt.getFRLT());
                }

                if (arpt.getFPTT() != null) {
                    //	计划起飞时间
                    entity.setFPTT(arpt.getFPTT());
                    //	预计起飞时间
                    entity.setFETT(arpt.getFETT());
                    //	实际起飞时间
                    entity.setFRTT(arpt.getFRTT());
                }
            }

            return entity;

        } else {
            return null;
        }
    }

    /**
     * 航班值机柜台信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltCounter(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                CheckInCounter ckls = JSONObject.parseObject(message, CheckInCounter.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(ckls.getFLID());

                // //	值机柜台列表
                entity.setCKLS(ckls.getCKNO());


                //	航班旅客值机预计开始时间
                entity.setFCES(MyDateUtil.parseDate(ckls.getESTR()));
                //	航班旅客值机预计结束时间
                entity.setFCEE(MyDateUtil.parseDate(ckls.getEEND()));
                //	航班旅客值机实际开始时间
                entity.setFCRS(MyDateUtil.parseDate(ckls.getRSTR()));
                //	航班旅客值机实际结束时间
                entity.setFCRE(MyDateUtil.parseDate(ckls.getREND()));
                //	航班旅客值机预计开始时间
                entity.setMCES(MyDateUtil.parseDate(ckls.getESTR()));
                //	航班旅客值机预计结束时间
                entity.setMCEE(MyDateUtil.parseDate(ckls.getEEND()));
                //	航班旅客值机实际开始时间
                entity.setMCRS(MyDateUtil.parseDate(ckls.getRSTR()));
                //	航班旅客值机实际结束时间
                entity.setMCRE(MyDateUtil.parseDate(ckls.getREND()));
                //	值机柜台及值机柜台区域显示
                // entity.setFCDP(ckls.getFCDP());
                //	值机柜台及值机柜台区域显示
                // entity.setMCDP(ckls.getMCDP());

                entity.setUPDATE_TIME(MyDateUtil.parseDate(ckls.getUPDATETIME()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltCounter出错，数据：{}", message, e);
        }
        return null;
    }

    /**
     * 航班登机门信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltGate(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                BoardingGate gate = JSONObject.parseObject(message, BoardingGate.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(gate.getFLID());
                //	登机门列表
                entity.setGTLS(gate.getGTNO());
                //	登机门 暂时使用第一条数据作为登机门
                entity.setGTNO(gate.getGTNO());

                entity.setUPDATE_TIME(MyDateUtil.parseDate(gate.getUPDATETIME()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltGate出错，数据：{}", message, e);
        }
        return null;
    }


    /**
     * 航班动态信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltInfo(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                FltInfo dflt = JSONObject.parseObject(message, FltInfo.class);
                FltInfoDynamic entity = new FltInfoDynamic();

                //	航班唯一编号
                entity.setFLID(dflt.getFLID());
                //	关联航班ID
                entity.setAFID(dflt.getAFID());
                //	航班标识
                entity.setFFID(dflt.getFFID());
                //	航空公司二字码
                entity.setAWCD(dflt.getAWCD());

                // 航空公司三字码
                BaseAirway baseAirway = Cache.baseAirwayMap.get(dflt.getAWCD());

                if (null != baseAirway) {
                    entity.setTRCD(baseAirway.getTrcd());
                }

                //	航班号
                entity.setFLNO(dflt.getFLNO());
                //	完整航班号 (航空公司二字码 + 航班号)
                if (dflt.getAWCD() != null && dflt.getFLNO() != null) {
                    entity.setFFLN(dflt.getAWCD() + dflt.getFLNO());
                }
                //	航班执行日期
                entity.setFEXD(MyDateUtil.parseDate(dflt.getFEXD()));
                //	航班所属计划批次的标识日期
                entity.setFIMD(MyDateUtil.parseDate(dflt.getFIMD()));
                //	进出港标识
                entity.setFLIO(dflt.getFLIO());
                //	航班任务
                entity.setFLTK(dflt.getFLTK());
                //	航班属性
                entity.setFATT(dflt.getFATT());
                //	主航班标识
                entity.setMFID(dflt.getMFID());
                //	主航班标识
                entity.setMFFI(dflt.getMFFI());
                //	起降架次
                entity.setCONT(dflt.getCONT());
                //	航班代理
                entity.setPROX(dflt.getPROX());
                //	机型
                entity.setCFTP(dflt.getCFTP());
                //	机号
                entity.setCFNO(dflt.getCFNO());
                //	航班状态
                entity.setSTAT(dflt.getSTAT());
                //	航班发布不正常状态
                entity.setABST(dflt.getABST());
                //	航班发布不正常原因
                entity.setABRS(dflt.getABRS());
                //	内部航班状态
                entity.setISTA(dflt.getISTA());
                //	内部航班不正常状态
                entity.setIAST(dflt.getIAST());
                //	航班发布状态
                entity.setMSTA(dflt.getMSTA());
                //	内部航班状态
                entity.setMIST(dflt.getMIST());
                //	航班发布不正常状态
                entity.setMABS(dflt.getMABS());
                //	内部航班不正常状态
                entity.setMIAS(dflt.getMIAS());
                //	航班发布不正常原因
                entity.setMABR(dflt.getMABR());
                //	内部航班不正常原因
                entity.setMIAR(dflt.getMIAR());
                //	内部航班不正常原因
                entity.setIARS(dflt.getIARS());
                //	航班开始登机实际时间
                entity.setBORT(MyDateUtil.parseDate(dflt.getBORT()));
                //	航班开始登机实际时间
                entity.setMBOR(MyDateUtil.parseDate(dflt.getMBOR()));
                //	航班过站登机实际时间
                entity.setTBRT(MyDateUtil.parseDate(dflt.getTBRT()));
                //	航班过站登机实际时间
                entity.setMTBR(MyDateUtil.parseDate(dflt.getMTBR()));
                //	航班催促登机实际时间
                entity.setLBDT(MyDateUtil.parseDate(dflt.getLBDT()));
                //	航班催促登机实际时间
                entity.setMLBD(MyDateUtil.parseDate(dflt.getMLBD()));
                //	航班结束登机实际时间
                entity.setPOKT(MyDateUtil.parseDate(dflt.getPOKT()));
                //	航班结束登机实际时间
                entity.setMPOK(MyDateUtil.parseDate(dflt.getMPOK()));
                //	备降航站
                entity.setAPOT(dflt.getAPOT());
                //	备降预计起飞时间
                entity.setDETT(MyDateUtil.parseDate(dflt.getDETT()));
                //	备降实际起飞时间
                entity.setDRTT(MyDateUtil.parseDate(dflt.getDRTT()));
                //	备降预计降落时间
                entity.setDELT(MyDateUtil.parseDate(dflt.getDELT()));
                //	备降实际降落时间
                entity.setDRLT(MyDateUtil.parseDate(dflt.getDRLT()));
                //	VIP人数
                entity.setVIP(dflt.getVIP());
                //	要客标识(VIP大于0 Y 等于0 N)
                entity.setVIP_FLG(dflt.getVIP() != null && dflt.getVIP() > 0 ? "Y" : "N");
                //	跑道消息
                entity.setRWAY(dflt.getRWAY());
                //	国内第一件行李上架时间
                entity.setFLDT(MyDateUtil.parseDate(dflt.getFLDT()));
                //	国内最后一件行李上架时间
                entity.setLLDT(MyDateUtil.parseDate(dflt.getLLDT()));
                //	国际最后一件行李上架时间
                entity.setMLLT(MyDateUtil.parseDate(dflt.getMLLT()));
                //	国际第一件行李上架时间
                entity.setMFLT(MyDateUtil.parseDate(dflt.getMFLT()));

                //	机场三字码 固定白云站
                entity.setAPCD("CAN");

                //	更新时间
                entity.setUPDATE_TIME(MyDateUtil.parseDate(dflt.getUPDATETIME()));

                return entity;

            }
        } catch (Throwable e) {
            log.error("handleFltInfo出错，数据：{}", message, e);
        }
        return null;
    }

    /**
     * 航班动态保障节点信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltSgDyn(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                FltSgDyn dyn = JSONObject.parseObject(message, FltSgDyn.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(dyn.getFLID());

                String code = dyn.getCODE();
                switch (code) {
                    case "01":
                        //	预计落地时间
                        entity.setETA(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际落地时间
                        entity.setATA(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "011":
                        //	计划监护到位时间
                        entity.setPSBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际监护到位时间
                        entity.setASBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "012":
                        //	计划勤务到位时间
                        entity.setPSST(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际勤务到位时间
                        entity.setASST(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "013":
                        //	预计进港时间
                        entity.setEBA(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进港时间
                        entity.setABA(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "0201":
                        //	计划进港地面移交时间
                        entity.setPGHT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进港地面移交时间
                        entity.setAGHT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "03":
                        //	计划引导车到位时间
                        entity.setPGBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际引导车到位时间
                        entity.setAGBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "04":
                        //	计划上轮档时间
                        entity.setSIBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际上轮档时间
                        entity.setAIBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "05":
                        //	计划靠梯桥时间
                        entity.setPJBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际靠梯桥时间
                        entity.setAJBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "051":
                        //	计划客梯车到位时间
                        entity.setPMBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际客梯车到位时间
                        entity.setAMBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "052":
                        //	计划进港摆渡车到位时间
                        entity.setSIBAT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进港摆渡车到位时间
                        entity.setAIBAT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "053":
                        //	计划第一辆进港摆渡车到位时间
                        entity.setPFIBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际第一辆进港摆渡车到位时间
                        entity.setAFIBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "06":
                        //	计划开客舱时间
                        entity.setPODT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际开客舱时间
                        entity.setAODT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "07":
                        //	计划清洁开始时间
                        entity.setPCST(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际清洁开始时间
                        entity.setACST(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "08":
                        //	计划清洁完成时间
                        entity.setPCET(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际清洁完成时间
                        entity.setACET(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "09":
                        //	计划开货舱时间
                        entity.setSCOT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际开货舱时间
                        entity.setACOT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "091":
                        //	计划开始下客时间
                        entity.setPDOT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际开始下客时间
                        entity.setADOT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "092":
                        //	计划下客完成时间
                        entity.setPDCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际下客完成时间
                        entity.setADCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "10":
                        //	计划首件行李时间
                        entity.setPFBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际首件行李时间
                        entity.setAFBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "11":
                        //	计划最后一件行李时间
                        entity.setPLBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际最后一件行李时间
                        entity.setALBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "112":
                        //	计划污水开始时间
                        entity.setPWST(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际污水开始时间
                        entity.setAWST(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "12":
                        //	计划污水完成时间
                        entity.setPWET(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际污水完成时间
                        entity.setAWET(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "121":
                        //	计划清水开始时间
                        entity.setPWWT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际清水开始时间
                        entity.setAWWT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "13":
                        //	计划清水完成时间
                        entity.setPWCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际清水完成时间
                        entity.setAWCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "14":
                        //	计划配餐开始时间
                        entity.setPCAT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际配餐开始时间
                        entity.setACAT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "15":
                        //	计划配餐完成时间
                        entity.setPCKT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际配餐完成时间
                        entity.setACKT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "151":
                        //	计划商旅完成时间
                        entity.setPBCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际商旅完成时间
                        entity.setABCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "16":
                        //	计划加油开始时间
                        entity.setPFRT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际加油开始时间
                        entity.setAFRT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "17":
                        //	计划加油完成时间
                        entity.setPFET(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际加油完成时间
                        entity.setAFET(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "171":
                        //	计划行李开始时间
                        entity.setPBDT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际行李开始时间
                        entity.setABDT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "172":
                        //	计划行李完成时间
                        entity.setSBFT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际行李完成时间
                        entity.setABFT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "18":
                        //	计划机务开始时间
                        entity.setPMTT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际机务开始时间
                        entity.setAMTT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "180":
                        //	计划首板货物入库时间
                        entity.setPFCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际首板货物入库时间
                        entity.setAFCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "181":
                        //	计划末板货物入库时间
                        entity.setPLCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际末板货物入库时间
                        entity.setALCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "19":
                        //	计划机务完成时间
                        entity.setPMCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际机务完成时间
                        entity.setAMCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "22":
                        //	计划通知上客时间
                        entity.setPNOT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际通知上客时间
                        entity.setANOT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "23":
                        //	计划登机开始时间
                        entity.setPBOT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际登机开始时间
                        entity.setABOT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "24":
                        //	计划登机结束时间
                        entity.setPBET(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际登机结束时间
                        entity.setABET(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "25":
                        //	计划上客完成时间
                        entity.setPSCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际上客完成时间
                        entity.setASCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "26":
                        //	计划配载完成时间
                        entity.setPLDT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际配载完成时间
                        entity.setALDT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "27":
                        //	计划出港摆渡车到达时间
                        entity.setPOAT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港摆渡车到达时间
                        entity.setAOAT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "271":
                        //	计划出港摆渡车撤离时间
                        entity.setSBRT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港摆渡车撤离时间
                        entity.setABRT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "272":
                        //	计划客梯车撤离时间
                        entity.setPMDT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际客梯车撤离时间
                        entity.setAMDT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "28":
                        //	计划关货舱时间
                        entity.setSCLT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际关货舱时间
                        entity.setACLT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "29":
                        //	计划关客舱时间
                        entity.setSCCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际关客舱时间
                        entity.setACCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "30":
                        //	计划撤梯桥时间
                        entity.setPJDT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际撤梯桥时间
                        entity.setAJDT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "32":
                        //	计划撤轮档时间
                        entity.setSOBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际撤轮档时间
                        entity.setAOBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "33":
                        //	计划牵引车到位时间
                        entity.setPTBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际牵引车到位时间
                        entity.setATBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "34":
                        //	计划申请推出时间
                        entity.setPPAT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际申请推出时间
                        entity.setAPAT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "35":
                        //	计划许可推出时间
                        entity.setPPPT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际许可推出时间
                        entity.setAPPT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "36":
                        //	计划牵引车完成时间
                        entity.setPTCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际牵引车完成时间
                        entity.setATCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "361":
                        //	计划监护撤离时间
                        entity.setPSMT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际监护撤离时间
                        entity.setASMT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "362":
                        //	计划引导车到位（出港）时间
                        entity.setSOGIT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际引导车到位（出港）时间
                        entity.setAOGIT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "363":
                        //	计划开客舱（出港）时间
                        entity.setSOCOT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际开客舱（出港）时间
                        entity.setAOCOT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "37":
                        //	计划滑出时间
                        entity.setPTOBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际滑出时间
                        entity.setATOBT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "3701":
                        //	计划出港地面移交时间
                        entity.setPGOT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港地面移交时间
                        entity.setAGOT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "39":
                        //	推算预计起飞时间
                        entity.setETD(MyDateUtil.parseDate(dyn.getESTT()));
                        break;
                    case "55":
                        //	计划机务放行时间
                        entity.setPMRT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际机务放行时间
                        entity.setAMRT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "60":
                        //	计划确认收到时间
                        entity.setPCRT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际确认收到时间
                        entity.setACRT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "62":
                        //	预计进机位时间
                        entity.setEBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进机位时间
                        entity.setABT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "66":
                        //	计划进港货物接收时间
                        entity.setPIRT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进港货物接收时间
                        entity.setAIRT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "67":
                        //	计划进港业务袋接收时间
                        entity.setPIBT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进港业务袋接收时间
                        entity.setSIBRT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "68":
                        //	计划进港业务袋送达时间
                        entity.setAIBRT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进港业务袋送达时间
                        entity.setAIDT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "69":
                        //	计划出港货物报载时间
                        entity.setSCMT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港货物报载时间
                        entity.setACMT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "70":
                        //	计划出港货物交接时间
                        entity.setSCXT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港货物交接时间
                        entity.setACXT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "71":
                        //	计划出港业务袋完成时间
                        entity.setSOBFT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港业务袋完成时间
                        entity.setAOBFT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "711":
                        //	计划国内出港文件交接时间
                        entity.setSDDXT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际国内出港文件交接时间
                        entity.setADDXT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "712":
                        //	计划国际出港文件交接时间
                        entity.setPIOT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际国际出港文件交接时间
                        entity.setAIOT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "713":
                        //	计划出港业务袋地勤确认交接时间
                        entity.setPOCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港业务袋地勤确认交接时间
                        entity.setAOCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "72":
                        //	计划出港业务袋送达时间
                        entity.setSOBDT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港业务袋送达时间
                        entity.setAOBDT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "73":
                        //	计划出港拉货接收时间
                        entity.setPLRT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际出港拉货接收时间
                        entity.setALRT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "74":
                        //	计划最后一辆摆渡车到达登机口时间
                        entity.setPLAT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际最后一辆摆渡车到达登机口时间
                        entity.setALAT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "76":
                        //	计划牵引车开始时间
                        entity.setPTST(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际牵引车开始时间
                        entity.setATST(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "77":
                        //	计划目标保障完成时刻时间
                        entity.setSTGCT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际目标保障完成时刻时间
                        entity.setATGCT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "79":
                        //	计划推出时间
                        entity.setPPUT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际推出时间
                        entity.setAPUT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;
                    case "888":
                        //	计划进港桥手到位时间
                        entity.setPBAT(MyDateUtil.parseDate(dyn.getESTT()));

                        //	实际进港桥手到位时间
                        entity.setABAT(MyDateUtil.parseDate(dyn.getRSTT()));
                        break;

                    default:
                        break;
                }


                entity.setUPDATE_TIME(MyDateUtil.parseDate(dyn.getUPDATETIME()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltSgDyn出错，数据：{}", message, e);
        }
        return null;
    }


    /**
     * 航班行李提取转盘信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltLugeftch(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                FltLugeftch item = JSONObject.parseObject(message, FltLugeftch.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(item.getFLID());

                //	行李提取转盘列表
                entity.setBLLS(item.getBTNO());

                entity.setUPDATE_TIME(MyDateUtil.parseDate(item.getUPDATETIME()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltLugeftch出错，数据：{}", message, e);
        }
        return null;
    }


    /**
     * 航班行李滑槽口信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltLugload(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                FltLugload item = JSONObject.parseObject(message, FltLugload.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(item.getFLID());

                //	航班行李滑槽口列表
                entity.setCHLS(item.getCHNO());

                entity.setUPDATE_TIME(MyDateUtil.parseDate(item.getUPDATETIME()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltLugeftch出错，数据：{}", message, e);
        }
        return null;
    }

    /**
     * 共享航班信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltShare(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                FltShare item = JSONObject.parseObject(message, FltShare.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(item.getFLID());

                entity.setSHARE_FLIGHT(item.getSFAW() + item.getSFNO());

                entity.setUPDATE_TIME(MyDateUtil.parseDate(item.getUPDATETIME()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltLugeftch出错，数据：{}", message, e);
        }
        return null;
    }

    /**
     * 航班机位信息
     *
     * @param message
     * @return
     */
    public static FltInfoDynamic handleFltStand(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                FltStand item = JSONObject.parseObject(message, FltStand.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(item.getFLID());

                // 当前机位
                entity.setSTND(item.getCODE());

                // 靠桥标识判断 - 使用机位基础信息表的ISREMOTEAPRON字段
                String standContact = "N"; // 默认不靠桥（远机位）
                if (item.getCODE() != null) {
                    BaseStand baseStand = Cache.baseStandMap.get(item.getCODE());
                    if (baseStand != null && baseStand.getIsRemoteApron() != null) {
                        // ISREMOTEAPRON: Y表示远机位，N表示近机位
                        // STND_CONTACT: Y表示靠桥（近机位），N表示不靠桥（远机位）
                        if ("N".equals(baseStand.getIsRemoteApron())) {
                            standContact = "Y"; // 近机位，靠桥
                        } else {
                            standContact = "N"; // 远机位，不靠桥
                        }
                    }
                }
                entity.setSTND_CONTACT(standContact);

                //	机位占用标识
                entity.setSTND_FIN("N");
                // 历史机位
                // entity.setSTND_HIS();

                entity.setUPDATE_TIME(MyDateUtil.parseDate(item.getUPDATETIME()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handleFltStand出错，数据：{}", message, e);
        }
        return null;
    }

    public static FltInfoDynamic handlePassenger(String message) {
        try {
            if (null != message && !message.isEmpty()) {
                Passenger item = JSONObject.parseObject(message, Passenger.class);
                FltInfoDynamic entity = new FltInfoDynamic();
                //	航班唯一编号
                entity.setFLID(Long.valueOf(item.getFLID()));
                entity.setBACKAGE_NUM(Integer.valueOf(item.getBACKAGE_NUM()));
                entity.setBACKAGE_WEIGHT(Integer.valueOf(item.getBACKAGE_WEIGHT()));
                entity.setPASS_ADNO(Integer.valueOf(item.getPASS_ADNO()));
                entity.setPASS_CDNO(Integer.valueOf(item.getPASS_CDNO()));
                entity.setADNO(Integer.valueOf(item.getADNO()));
                entity.setCDNO(Integer.valueOf(item.getCDNO()));
                return entity;
            }
        } catch (Throwable e) {
            log.error("handlePassengerInfo出错，数据：{}", message, e);
        }
        return null;
    }

}
